// 基于MediaSource的音频流播放类，参考voice.html的实现
export class AudioPlayer {
  private mediaSource: MediaSource | null = null;
  private sourceBuffer: SourceBuffer | null = null;
  private audioQueue: Uint8Array[] = [];
  private isAudioReady = false;
  private currentStreamingAudio: HTMLAudioElement | null = null;
  private isPlaying = false;
  private hasStartedPlaying = false;

  // 新增：播放状态回调
  private onPlayStateChange?: (isPlaying: boolean, duration?: number, audioData?: string) => void;

  // 新增：存储完整音频数据
  private audioChunks: Uint8Array[] = [];

  // 新增：超时检测相关
  private lastDataReceiveTime: number = 0;
  private playbackCheckInterval: NodeJS.Timeout | null = null;

  // 新增：移动端检测和备用机制
  private isMobile: boolean = false;
  private mobilePlaybackTimer: NodeJS.Timeout | null = null;
  // private lastChunkReceiveTime: number = 0;
  private hasReceivedData: boolean = false;

  // 新增：移动端播放按钮状态
  private canPlayAudio: boolean = false; // 音频是否可以播放（移动端显示按钮的标志）
  private onCanPlayCallback?: (canPlay: boolean) => void; // 可播放状态变化回调

  // 🔥 新增：PC端精确检测相关
  private streamCompleted: boolean = false; // 流是否已完成
  private lastPlayTime: number = 0; // 最后播放时间位置
  private playTimeCheckCount: number = 0; // 播放时间检查计数器
  private isInPreciseMode: boolean = false; // 是否处于精确检测模式
  private lastProgressUpdateTime: number = 0; // 最后进度更新时间
  private stuckCheckCount: number = 0; // 卡住检查计数器

  constructor() {
    // 检测是否为移动端
    this.isMobile = this.detectMobile();
    // console.log('🎵 AudioPlayer初始化 - 移动端:', this.isMobile);
    this.initStreamingAudio();
  }

  // 检测移动端
  private detectMobile(): boolean {
    const userAgent = navigator.userAgent.toLowerCase();
    const isMobileUA = /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/.test(userAgent);
    const isMobileScreen = window.innerWidth <= 1010;
    return isMobileUA || isMobileScreen;
  }

  // 设置播放状态变化回调
  setPlayStateCallback(callback: (isPlaying: boolean, duration?: number, audioData?: string) => void) {
    this.onPlayStateChange = callback;
  }

  // 设置可播放状态变化回调（移动端专用）
  setCanPlayCallback(callback: (canPlay: boolean) => void) {
    this.onCanPlayCallback = callback;
  }

  // 初始化流式音频播放
  private initStreamingAudio(): boolean {
    if (!window.MediaSource) {
      console.warn("MediaSource API not supported, fallback to non-streaming");
      return false;
    }

    try {
      this.mediaSource = new MediaSource();
      this.currentStreamingAudio = new Audio();
      this.currentStreamingAudio.src = URL.createObjectURL(this.mediaSource);

      this.mediaSource.addEventListener('sourceopen', () => {
        try {
          // 使用audio/mpeg for MP3 data
          this.sourceBuffer = this.mediaSource!.addSourceBuffer('audio/mpeg');
          this.sourceBuffer.addEventListener('updateend', () => this.processAudioQueue());
          this.isAudioReady = true;
        } catch (error) {
          console.error("Failed to create source buffer:", error);
          return false;
        }
      });

      // 🔥 新增：PC端MediaSource状态监听
      if (!this.isMobile) {
        this.mediaSource.addEventListener('sourceended', () => {
          // console.log('🎵 [PC端] MediaSource sourceended事件触发');
          this.onMediaSourceEnded();
        });

        // this.mediaSource.addEventListener('sourceclose', () => {
        //   console.log('🎵 [PC端] MediaSource sourceclose事件触发');
        // });
      }

      // 🔥 新增：PC端音频播放进度监听
      if (!this.isMobile) {
        this.setupPlaybackProgressMonitoring();
      }

      return true;
    } catch (error) {
      console.error("Failed to initialize streaming audio:", error);
      return false;
    }
  }

  // 处理音频队列
  private processAudioQueue() {
    if (this.sourceBuffer && !this.sourceBuffer.updating && this.audioQueue.length > 0) {
      const audioData = this.audioQueue.shift()!;
      try {
        this.sourceBuffer.appendBuffer(audioData);

        // PC端：处理第一个音频数据后立即尝试播放
        if (!this.hasStartedPlaying && !this.isMobile && this.currentStreamingAudio) {
          // console.log('🎵 [PC端] 音频数据已添加到缓冲区，尝试播放');
          // 短暂延迟让缓冲区更新完成
          setTimeout(() => {
            if (!this.hasStartedPlaying) {
              this.attemptPlayback(0);
            }
          }, 5);
        }
      } catch (error) {
        console.error("Failed to append audio data:", error);
      }
    }
  }

  // hex字符串转Uint8Array
  private hexToUint8Array(hex: string): Uint8Array {
    const bytes = new Uint8Array(hex.length / 2);
    for (let i = 0; i < hex.length; i += 2) {
      bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
    }
    return bytes;
  }

  // 添加音频块到流
  async addAudioChunk(chunkId: number, hexData: string) {
    try {
      const bytes = this.hexToUint8Array(hexData);

      // 更新最后接收数据的时间
      this.lastDataReceiveTime = Date.now();
      // this.lastChunkReceiveTime = Date.now();
      this.hasReceivedData = true;
      // console.log('🎵 接收到音频块:', chunkId, '时间:', new Date().toISOString(), '移动端:', this.isMobile);

      // 存储音频块用于后续保存
      this.audioChunks.push(bytes);

      if (this.isAudioReady && this.sourceBuffer) {
        this.audioQueue.push(bytes);
        this.processAudioQueue();

        // PC端：收到第一个音频块就立即尝试播放并开始超时检测
        if (!this.hasStartedPlaying && this.currentStreamingAudio && !this.isMobile) {
          // console.log('🎵 [PC端] 收到第一个音频块，立即开始播放尝试');
          // 立即尝试播放，不延迟
          this.startPlaybackWhenReady();
          this.startPlaybackTimeoutCheck();
        }
      } else {
        this.audioQueue.push(bytes);

        // PC端：即使音频还没准备好也要尝试播放
        if (!this.hasStartedPlaying && this.currentStreamingAudio && !this.isMobile) {
          // console.log('🎵 [PC端] 音频未准备好，但仍尝试播放');
          // 稍微延迟一点让MediaSource初始化
          setTimeout(() => {
            this.startPlaybackWhenReady();
            this.startPlaybackTimeoutCheck();
          }, 20);
        }

        // 移动端保持原有逻辑
        if (!this.hasStartedPlaying && this.currentStreamingAudio && this.isMobile) {
          setTimeout(() => {
            this.startPlaybackWhenReady();
            this.startPlaybackTimeoutCheck();
          }, 50);
        }
      }
    } catch (error) {
      // console.error("处理音频块时出错:", error);
      console.error('addAudioChunk failed', error);
    }
  }

  // 当有足够缓冲时开始播放
  private startPlaybackWhenReady() {
    if (this.hasStartedPlaying || !this.currentStreamingAudio) return;

    // 立即尝试播放，如果失败则短暂重试
    this.attemptPlayback(0);
  }

  // 开始播放超时检测 - 针对移动端优化
  private startPlaybackTimeoutCheck() {
    // 清除之前的检测器
    if (this.playbackCheckInterval) {
      clearInterval(this.playbackCheckInterval);
    }
    if (this.mobilePlaybackTimer) {
      clearTimeout(this.mobilePlaybackTimer);
    }

    // console.log('🎵 开始超时检测机制 - 移动端:', this.isMobile);

    if (this.isMobile) {
      // 移动端使用更短的检测间隔和备用机制
      this.playbackCheckInterval = setInterval(() => {
        const now = Date.now();
        const timeSinceLastData = now - this.lastDataReceiveTime;

        // 移动端缩短到3秒超时
        if (timeSinceLastData > 3000 && this.isPlaying && this.hasStartedPlaying) {
          // console.log('🔥🔥🔥 [移动端] 检测到3秒内无新数据，播放完成！！！');
          // console.log('🎵 距离最后接收数据:', timeSinceLastData, 'ms');
          this.handlePlaybackComplete();
        }

        // 移动端额外检查：如果有数据但播放状态异常，强制完成
        if (this.hasReceivedData && !this.isPlaying && this.hasStartedPlaying && timeSinceLastData > 2000) {
          // console.log('🔥🔥🔥 [移动端] 检测到播放状态异常，强制完成！！！');
          this.handlePlaybackComplete();
        }
      }, 300); // 移动端更频繁检查

      // 移动端备用超时机制：8秒强制完成
      this.mobilePlaybackTimer = setTimeout(() => {
        if (this.hasReceivedData && this.isPlaying) {
          // console.log('🔥🔥🔥 [移动端] 8秒备用超时，强制完成播放！！！');
          this.handlePlaybackComplete();
        }
      }, 8000);
    } else {
      // 🔥 PC端改进：多重检测机制，提高检查频率
      this.playbackCheckInterval = setInterval(() => {
        this.performPCPlaybackCheck();
      }, 100); // 更频繁检查：100ms
    }
  }

  // 🔥 新增：设置PC端播放进度监控
  private setupPlaybackProgressMonitoring() {
    if (!this.currentStreamingAudio || this.isMobile) return;

    // 监听播放进度变化 - 更保守的检测
    this.currentStreamingAudio.addEventListener('timeupdate', () => {
      if (!this.isPlaying || !this.hasStartedPlaying) return;

      const currentTime = this.currentStreamingAudio!.currentTime;
      const now = Date.now();

      // 记录进度更新时间
      this.lastProgressUpdateTime = now;

      // 检测播放进度变化（提高精度到0.05秒）
      if (Math.abs(currentTime - this.lastPlayTime) >= 0.05) {
        // 播放进度正常更新，重置所有计数器
        this.playTimeCheckCount = 0;
        this.stuckCheckCount = 0;
        this.lastPlayTime = currentTime;

        // 减少进度日志噪音，只在重要时刻输出
        if (currentTime % 1 < 0.1) { // 大约每秒输出一次
          // console.log('🎵 [PC端] 播放进度更新:', {
          //   currentTime: currentTime.toFixed(1),
          //   duration: this.currentStreamingAudio!.duration?.toFixed(1) || 'unknown'
          // });
        }
      }
    });

    // 监听播放结束事件（最可靠的检测方式）
    this.currentStreamingAudio.addEventListener('ended', () => {
      // console.log('🔥🔥🔥 [PC端] Audio ended事件触发，播放完成！！！');
      if (this.isPlaying) {
        this.handlePlaybackComplete();
      }
    });

    // 监听播放错误
    this.currentStreamingAudio.addEventListener('error', (e) => {
      // console.error('🎵 [PC端] 音频播放错误:', e);
      console.error('audio playback error', e);
    });

    // 监听播放暂停
    // this.currentStreamingAudio.addEventListener('pause', () => {
    // console.log('🎵 [PC端] 音频被暂停');
    // });

    // console.log('🎵 [PC端] 播放进度监控已设置');
  }

  // 🔥 新增：MediaSource结束事件处理
  private onMediaSourceEnded() {
    this.streamCompleted = true;
    this.isInPreciseMode = true;
  }

  // 🔥 新增：PC端播放检查逻辑 - 重新设计为更保守的检测
  private performPCPlaybackCheck() {
    if (!this.isPlaying || !this.hasStartedPlaying || this.isMobile || !this.currentStreamingAudio) return;

    const now = Date.now();
    const timeSinceLastData = now - this.lastDataReceiveTime;
    const timeSinceLastProgress = now - this.lastProgressUpdateTime;

    // 🔥 调整超时时间：精确模式更快响应
    const dataTimeoutDuration = this.isInPreciseMode ? 2000 : 5000; // 精确模式2秒，普通模式5秒
    const progressTimeoutDuration = this.isInPreciseMode ? 3000 : 8000; // 精确模式3秒，普通模式8秒

    const audio = this.currentStreamingAudio;
    const currentTime = audio.currentTime;
    const duration = audio.duration;
    const buffered = audio.buffered;

    // 关键状态检查
    const isAudioPaused = audio.paused;
    const isAudioEnded = audio.ended;
    const hasValidDuration = duration && isFinite(duration) && duration > 0;

    // 只在关键状态变化时输出日志
    const shouldLog = this.streamCompleted || isAudioEnded || isAudioPaused ||
      timeSinceLastData > 2000 || timeSinceLastProgress > 2000;

    if (shouldLog) {
      // console.log('🎵 [PC端] 播放状态检查:', {
      //   currentTime: currentTime.toFixed(2),
      //   duration: hasValidDuration ? duration.toFixed(2) : 'unknown',
      //   paused: isAudioPaused,
      //   ended: isAudioEnded,
      //   streamCompleted: this.streamCompleted,
      //   timeSinceLastData,
      //   timeSinceLastProgress,
      //   mode: this.isInPreciseMode ? 'precise' : 'normal'
      // });
    }

    // 1. 最可靠的检测：HTMLAudioElement的ended状态
    if (isAudioEnded) {
      // console.log('🔥🔥🔥 [PC端] Audio.ended=true，播放完成！！！');
      this.handlePlaybackComplete();
      return;
    }

    // 2. 检查音频是否被意外暂停
    if (isAudioPaused) {
      // console.warn('🎵 [PC端] 音频被暂停，可能已完成或出现问题');
      console.warn('audio is paused, may be completed or there is a problem');
      // 不立即判定为完成，可能是临时暂停
      return;
    }

    // 3. 🔥 增强的快速检测：缓冲区末尾检测（无需等待精确模式）
    if (buffered.length > 0) {
      const lastBufferedEnd = buffered.end(buffered.length - 1);
      const distanceToEnd = lastBufferedEnd - currentTime;

      // 如果播放位置非常接近缓冲区末尾，且流已完成
      if (this.streamCompleted && distanceToEnd < 0.3) {
        // 进一步检查：是否超过短暂延迟
        if (timeSinceLastData > 1000) { // 只需1秒
          // console.log('🔥🔥🔥 [PC端] 流完成且播放接近缓冲区末尾，播放完成！！！', {
          //   currentTime: currentTime.toFixed(2),
          //   lastBufferedEnd: lastBufferedEnd.toFixed(2),
          //   distanceToEnd: distanceToEnd.toFixed(3),
          //   timeSinceLastData
          // });
          this.handlePlaybackComplete();
          return;
        }
      }
    }

    // 4. 精确模式的严格检测
    if (this.isInPreciseMode && this.streamCompleted) {
      // 检查播放位置是否接近已知总时长
      if (hasValidDuration && currentTime >= duration - 0.2) {
        // console.log('🔥🔥🔥 [PC端] 播放位置接近总时长末尾，播放完成！！！', {
        //   currentTime: currentTime.toFixed(2),
        //   duration: duration.toFixed(2),
        //   remaining: (duration - currentTime).toFixed(2)
        // });
        this.handlePlaybackComplete();
        return;
      }

      // 检查缓冲区：播放位置是否到达所有缓冲区的末尾
      if (buffered.length > 0) {
        const lastBufferedEnd = buffered.end(buffered.length - 1);
        const isAtBufferEnd = lastBufferedEnd - currentTime < 0.05; // 极严格：0.05秒

        if (isAtBufferEnd && timeSinceLastData > dataTimeoutDuration) {
          // console.log('🔥🔥🔥 [PC端] 精确模式：播放到达缓冲区末尾且数据超时，播放完成！！！', {
          //   currentTime: currentTime.toFixed(2),
          //   lastBufferedEnd: lastBufferedEnd.toFixed(2),
          //   timeSinceLastData
          // });
          this.handlePlaybackComplete();
          return;
        }
      }
    }

    // 5. 最后的兜底检测：播放进度长时间无更新且数据长时间无接收
    if (timeSinceLastProgress > progressTimeoutDuration && timeSinceLastData > dataTimeoutDuration) {
      // console.log('🔥🔥🔥 [PC端] 播放进度和数据接收均长时间超时，播放完成！！！', {
      //   timeSinceLastProgress,
      //   timeSinceLastData
      // });
      this.handlePlaybackComplete();
      return;
    }

    // 6. 🔥 新增：流完成后的快速检测机制
    if (this.streamCompleted && timeSinceLastData > 500) {
      // 检查播放时间是否已停止变化
      const timeSinceLastProgressUpdate = now - this.lastProgressUpdateTime;
      if (timeSinceLastProgressUpdate > 800) { // 800ms无进度更新
        // console.log('🔥🔥🔥 [PC端] 流完成后播放进度停滞，播放完成！！！', {
        //   timeSinceLastData,
        //   timeSinceLastProgressUpdate,
        //   currentTime: currentTime.toFixed(2)
        // });
        this.handlePlaybackComplete();
        return;
      }
    }
  }

  // 处理播放完成
  private handlePlaybackComplete() {
    // console.log('🎵 处理播放完成逻辑 - 移动端:', this.isMobile);

    // 清除检测器
    if (this.playbackCheckInterval) {
      clearInterval(this.playbackCheckInterval);
      this.playbackCheckInterval = null;
    }
    if (this.mobilePlaybackTimer) {
      clearTimeout(this.mobilePlaybackTimer);
      this.mobilePlaybackTimer = null;
    }

    this.isPlaying = false;
    // console.log('🎵 设置播放状态为 false');

    // 获取音频时长，处理无效值
    const rawDuration = this.currentStreamingAudio?.duration;
    const duration = this.getValidDuration(rawDuration);
    // console.log('🎵 原始音频时长:', rawDuration, '处理后时长:', duration);

    // 立即通知播放状态变化
    // console.log('🎵 调用播放状态回调...');
    this.onPlayStateChange?.(false, duration);
    // console.log('🎵 播放状态回调调用完成');

    // 异步获取音频数据
    const audioBlob = this.getAudioBlob();
    if (audioBlob) {
      const reader = new FileReader();
      reader.onload = () => {
        const audioData = (reader.result as string).split(',')[1];
        // console.log('🎵 音频数据准备完成，再次更新状态');
        this.onPlayStateChange?.(false, duration, audioData);
      };
      reader.readAsDataURL(audioBlob);
    } else {
      // console.log('🎵 没有音频数据，使用空数据回调');
      // 即使没有音频数据，也要确保状态更新
      this.onPlayStateChange?.(false, duration, '');
    }
  }

  // 获取有效的音频时长
  private getValidDuration(duration?: number): number {
    if (!duration || !isFinite(duration) || isNaN(duration) || duration <= 0) {
      // 如果没有有效时长，使用播放时间估算
      const playTime = this.currentStreamingAudio?.currentTime;
      if (playTime && isFinite(playTime) && playTime > 0) {
        // console.log('🎵 使用播放时间作为时长:', playTime);
        return playTime;
      }
      // 如果都没有，返回一个合理的默认值
      // console.log('🎵 使用默认时长: 1秒');
      return 1;
    }
    return duration;
  }

  // 移动端手动开始播放（用户点击播放按钮触发）
  startPlaybackManually() {
    if (!this.isMobile || !this.canPlayAudio || this.hasStartedPlaying || !this.currentStreamingAudio) {
      // console.warn('🎵 [移动端] 无法手动开始播放:', {
      //   isMobile: this.isMobile,
      //   canPlayAudio: this.canPlayAudio,
      //   hasStartedPlaying: this.hasStartedPlaying,
      //   hasAudio: !!this.currentStreamingAudio
      // });
      console.warn('cannot manually start playback', {
        isMobile: this.isMobile,
        canPlayAudio: this.canPlayAudio,
        hasStartedPlaying: this.hasStartedPlaying,
        hasAudio: !!this.currentStreamingAudio
      });
      return;
    }

    // console.log('🎵 [移动端] 用户手动开始播放');

    this.currentStreamingAudio.play().then(() => {
      // console.log('🎵 [移动端] 手动播放成功');
      this.hasStartedPlaying = true;
      this.isPlaying = true;
      this.canPlayAudio = false; // 隐藏播放按钮

      // 通知状态变化
      this.onCanPlayCallback?.(false); // 隐藏播放按钮
      this.onPlayStateChange?.(true); // 通知开始播放

      // console.log('🎵 [移动端] 手动播放状态回调完成');
    }).catch(error => {
      // console.error('🎵 [移动端] 手动播放失败:', error);
      console.error('manual playback failed', error);
    });
  }

  // 尝试播放音频，带重试机制
  private attemptPlayback(retryCount: number) {
    if (this.hasStartedPlaying || !this.currentStreamingAudio || retryCount > 20) return;

    // PC端：更积极的播放条件，只要有音频数据就尝试播放
    const hasData = this.sourceBuffer && this.sourceBuffer.buffered.length > 0;
    const readyToPlay = this.currentStreamingAudio.readyState >= 1; // HAVE_METADATA
    const hasAudioChunks = this.audioChunks.length > 0; // 新增：只要有音频块就尝试

    // PC端：只要有任何音频数据就尝试播放
    const canAttemptPlay = hasData || readyToPlay || (hasAudioChunks && !this.isMobile);

    // console.log('🎵 播放条件检查:', {
    //   hasData,
    //   readyToPlay,
    //   hasAudioChunks,
    //   canAttemptPlay,
    //   isMobile: this.isMobile,
    //   retryCount
    // });

    if (canAttemptPlay) {
      // 移动端：设置可播放状态，显示播放按钮
      if (this.isMobile && !this.canPlayAudio) {
        // console.log('🎵 [移动端] 音频可播放，显示播放按钮');
        this.canPlayAudio = true;
        this.onCanPlayCallback?.(true);
        return; // 移动端不自动播放，等待用户点击
      }

      // PC端：自动播放
      if (!this.isMobile) {
        // console.log('🎵 [PC端] 条件满足，尝试播放音频');
        this.currentStreamingAudio.play().then(() => {
          // console.log('🎵 [PC端] 音频开始播放成功');
          this.hasStartedPlaying = true;
          this.isPlaying = true;
          // console.log('🎵 设置播放状态为 true');
          // 立即通知播放状态变化
          this.onPlayStateChange?.(true);
          // console.log('🎵 播放开始状态回调调用完成');
        }).catch(error => {
          // console.log('🎵 [PC端] 播放失败，准备重试:', error)
          // 播放失败，快速重试
          const nextRetryDelay = retryCount < 5 ? 10 : 30;
          setTimeout(() => {
            this.attemptPlayback(retryCount + 1);
          }, nextRetryDelay);
        });
      }
    } else {
      // 数据还没准备好，快速重试
      // console.log('🎵 播放条件不满足，准备重试');
      const nextRetryDelay = retryCount < 10 ? 20 : 50;
      setTimeout(() => {
        this.attemptPlayback(retryCount + 1);
      }, nextRetryDelay);
    }
  }

  // 完成流式音频
  completeStream() {
    try {
      // console.log('🎵 音频流传输完成，设置最后接收时间 - 移动端:', this.isMobile);
      // 更新最后接收数据时间，让超时检测机制触发播放完成
      this.lastDataReceiveTime = Date.now();

      // 🔥 PC端：标记流完成状态
      if (!this.isMobile) {
        this.streamCompleted = true;
        // console.log('🎵 [PC端] 标记音频流已完成');
      }

      if (this.mediaSource && this.mediaSource.readyState === 'open') {
        // 处理剩余的队列
        if (this.audioQueue.length > 0) {
          const remainingData = this.audioQueue.shift()!;
          if (this.sourceBuffer && !this.sourceBuffer.updating) {
            this.sourceBuffer.appendBuffer(remainingData);
            this.sourceBuffer.addEventListener('updateend', () => {
              if (this.audioQueue.length === 0) {
                this.mediaSource!.endOfStream();
              }
            }, { once: true });
          }
        } else {
          this.mediaSource.endOfStream();
        }
      }

      // 移动端额外检查：如果流完成但没有开始播放，强制触发完成
      if (this.isMobile && this.hasReceivedData && !this.hasStartedPlaying) {
        // console.log('🔥🔥🔥 [移动端] 流完成但未开始播放，2秒后强制完成');
        setTimeout(() => {
          if (!this.hasStartedPlaying && this.hasReceivedData) {
            // console.log('🔥🔥🔥 [移动端] 强制触发播放完成');
            this.handlePlaybackComplete();
          }
        }, 2000);
      }

      // 设置一些调试事件监听器
      if (this.currentStreamingAudio) {
        // this.currentStreamingAudio.addEventListener('loadedmetadata', () => {
        //   console.log('🎵 音频元数据加载完成, 时长:', this.currentStreamingAudio?.duration);
        // });

        // this.currentStreamingAudio.addEventListener('canplay', () => {
        //   console.log('🎵 音频可以开始播放');
        // });

        // this.currentStreamingAudio.addEventListener('play', () => {
        //   console.log('🎵 音频开始播放');
        // });

        // 移动端额外监听ended事件作为备用
        if (this.isMobile) {
          this.currentStreamingAudio.addEventListener('ended', () => {
            // console.log('🔥🔥🔥 [移动端] 音频ended事件触发，播放完成');
            if (this.isPlaying) {
              this.handlePlaybackComplete();
            }
          });
        }
      }
    } catch (error) {
      // console.error("完成流式音频时出错:", error);
      console.error('complete stream failed', error);
    }
  }

  // 获取完整音频数据作为Blob
  getAudioBlob(): Blob | null {
    if (this.audioChunks.length === 0) return null;

    // 计算总长度
    const totalLength = this.audioChunks.reduce((sum, chunk) => sum + chunk.length, 0);

    // 合并所有音频块
    const mergedArray = new Uint8Array(totalLength);
    let offset = 0;
    for (const chunk of this.audioChunks) {
      mergedArray.set(chunk, offset);
      offset += chunk.length;
    }

    // 创建音频Blob
    return new Blob([mergedArray], { type: 'audio/mpeg' });
  }

  // 暂停播放
  pause() {
    if (this.currentStreamingAudio && !this.currentStreamingAudio.paused) {
      this.currentStreamingAudio.pause();
      this.isPlaying = false;
      // 触发状态变化回调，通知UI更新
      this.onPlayStateChange?.(false);
    }
  }

  // 恢复播放
  resume() {
    if (this.currentStreamingAudio && this.currentStreamingAudio.paused) {
      this.currentStreamingAudio.play().then(() => {
        this.isPlaying = true;
      }).catch(error => {
        // console.error("恢复播放失败:", error);
        console.error('resume playback failed', error);
      });
    }
  }

  // 停止播放
  stop() {
    this.pause();
    this.reset();
  }

  // 重置音频状态
  reset() {
    try {
      // 清除超时检测
      if (this.playbackCheckInterval) {
        clearInterval(this.playbackCheckInterval);
        this.playbackCheckInterval = null;
      }
      if (this.mobilePlaybackTimer) {
        clearTimeout(this.mobilePlaybackTimer);
        this.mobilePlaybackTimer = null;
      }

      if (this.currentStreamingAudio) {
        this.currentStreamingAudio.pause();
        URL.revokeObjectURL(this.currentStreamingAudio.src);
        this.currentStreamingAudio = null;
      }

      if (this.mediaSource) {
        this.mediaSource = null;
      }

      this.sourceBuffer = null;
      this.audioQueue = [];
      this.audioChunks = []; // 清空音频块
      this.isAudioReady = false;
      this.isPlaying = false;
      this.hasStartedPlaying = false;
      this.lastDataReceiveTime = 0; // 重置时间
      // this.lastChunkReceiveTime = 0;
      this.hasReceivedData = false;
      this.canPlayAudio = false; // 重置可播放状态

      // 🔥 重置PC端精确检测相关状态
      this.streamCompleted = false;
      this.lastPlayTime = 0;
      this.playTimeCheckCount = 0;
      this.isInPreciseMode = false;
      this.lastProgressUpdateTime = 0;
      this.stuckCheckCount = 0;

      // 重新初始化
      this.initStreamingAudio();
    } catch (error) {
      // console.error("重置音频时出错:", error);
      console.error('reset audio failed', error);
    }
  }

  // 销毁资源
  destroy() {
    try {
      this.stop();
    } catch (error) {
      // console.error("销毁音频播放器时出错:", error);
      console.error('destroy audio player failed', error);
    }
  }

  // 从base64数据或URL播放音频（用于重播和移动端非流式播放）
  async playFromAudioData(audioData: string): Promise<void> {
    try {
      // 重置当前状态
      this.reset();

      // console.log('🎵 开始播放音频数据:', {
      //   isMobile: this.isMobile,
      //   hasData: !!audioData,
      //   dataLength: audioData?.length || 0,
      //   isUrl: audioData?.startsWith('http')
      // });

      // 创建新的Audio元素播放
      this.currentStreamingAudio = new Audio();

      // 检测是URL还是base64数据
      if (audioData.startsWith('http://') || audioData.startsWith('https://')) {
        // 如果是URL，直接使用
        // console.log('🎵 检测到URL音频数据，直接播放');
        this.currentStreamingAudio.src = audioData;
      } else {
        // 如果是base64数据，转换为Blob
        // console.log('🎵 检测到base64音频数据，转换后播放');
        const binaryString = atob(audioData);
        const bytes = new Uint8Array(binaryString.length);
        for (let i = 0; i < binaryString.length; i++) {
          bytes[i] = binaryString.charCodeAt(i);
        }
        const audioBlob = new Blob([bytes], { type: 'audio/mpeg' });
        this.currentStreamingAudio.src = URL.createObjectURL(audioBlob);
      }

      // 设置播放事件
      this.currentStreamingAudio.addEventListener('loadedmetadata', () => {
        // console.log('🎵 音频元数据加载完成，开始播放');
        this.isPlaying = true;
        this.hasStartedPlaying = true;
        this.onPlayStateChange?.(true);
      });

      this.currentStreamingAudio.addEventListener('ended', () => {
        // console.log('🔥🔥🔥 音频播放完成事件被触发！！！');
        // console.log('🎵 当前播放状态:', this.isPlaying);
        this.isPlaying = false;
        // console.log('🎵 更新播放状态为 false');

        // 获取有效的音频时长
        const rawDuration = this.currentStreamingAudio?.duration;
        const duration = this.getValidDuration(rawDuration);
        // console.log('🎵 原始时长:', rawDuration, '处理后时长:', duration);

        // 直接传递音频数据
        // console.log('🎵 调用播放状态回调...');
        this.onPlayStateChange?.(false, duration, audioData);
        // console.log('🎵 播放状态回调调用完成');
      });

      // 开始播放
      await this.currentStreamingAudio.play();
      // console.log('🎵 音频播放开始成功');
    } catch (error) {
      // console.error("播放音频失败:", error);
      console.error('play audio failed', error);
      // 播放失败时也要重置状态
      this.isPlaying = false;
      this.hasStartedPlaying = false;
      throw error;
    }
  }

  // 获取播放状态
  getPlaybackStatus() {
    return {
      isPlaying: this.isPlaying,
      hasStartedPlaying: this.hasStartedPlaying,
      queueLength: this.audioQueue.length,
      isReady: this.isAudioReady,
      canPlayAudio: this.canPlayAudio, // 新增：是否可播放（移动端）
      isMobile: this.isMobile
    };
  }

  // 详细状态日志
  logDetailedStatus() {
    // console.log('AudioPlayer Status:', {
    //   isPlaying: this.isPlaying,
    //   hasStartedPlaying: this.hasStartedPlaying,
    //   queueLength: this.audioQueue.length,
    //   isReady: this.isAudioReady,
    //   mediaSourceState: this.mediaSource?.readyState,
    //   audioElement: this.currentStreamingAudio ? {
    //     paused: this.currentStreamingAudio.paused,
    //     readyState: this.currentStreamingAudio.readyState,
    //     currentTime: this.currentStreamingAudio.currentTime,
    //     duration: this.currentStreamingAudio.duration
    //   } : null
    // });
  }
}

// 格式化音频时长 (秒 => 1'2" 格式)
export function formatAudioDuration(seconds: number): string {
  // 检查无效数值
  if (!seconds || !isFinite(seconds) || isNaN(seconds) || seconds <= 0) {
    // console.log('🎵 无效的音频时长:', seconds, '使用默认值 1"');
    return '1"';
  }

  const minutes = Math.floor(seconds / 60);
  const remainingSeconds = Math.floor(seconds % 60);

  if (minutes > 0) {
    return `${minutes}'${remainingSeconds}"`;
  } else {
    return `${remainingSeconds}"`;
  }
}

// 格式化时间显示 - 欧美标准AM/PM格式
export function formatMessageTime(timestamp: number): string {
  const now = Date.now();
  const diffHours = (now - timestamp) / (1000 * 60 * 60);
  const date = new Date(timestamp);

  if (diffHours > 24) {
    // 大于24小时：显示日期 + 时间 (MM/DD/YYYY, H:MM AM/PM)
    return date.toLocaleString('en-US', {
      month: '2-digit',
      day: '2-digit',
      year: 'numeric',
      hour: 'numeric',
      minute: '2-digit',
      hour12: true
    });
  } else {
    // 24小时内：只显示时间 (H:MM AM/PM)
    return date.toLocaleTimeString('en-US', {
      hour: 'numeric',
      minute: '2-digit',
      hour12: true
    });
  }
} 